farm.h

Go to the documentation of this file.

/*
*******************************************************************************************************
Copyright (c) 2011, Christopher John Topping, University of Aarhus
All rights reserved.
 
Redistribution and use in source and binary forms, with or without modification, are permitted provided
that the following conditions are met:
 
Redistributions of source code must retain the above copyright notice, this list of conditions and the
following disclaimer.
Redistributions in binary form must reproduce the above copyright notice, this list of conditions and
the following disclaimer in the documentation and/or other materials provided with the distribution.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR
IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS
BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
********************************************************************************************************
*/
//
// farm.h
//
/*
 
Copyright (c) 2003, National Environmental Research Institute, Denmark (NERI)
 
All rights reserved.
 
 
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
 
*) Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
*) Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
*) Neither the name of the NERI nor the names of its contributors
may be used to endorse or promote products derived from this software without
specific prior written permission.
 
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
 
*/
 
#ifndef FARM_H
#define FARM_H
 
// This really needs to be a #define.
#define PROG_START 1
 
 
class Population_Manager;
class FarmManager;
class BroadBeans;
class Carrots;
class CloverGrassGrazed1;
class CloverGrassGrazed2;
class FieldPeas;
class FieldPeasSilage;
class Fodderbeet;
class FodderGrass;
class Maize;
class MaizeSilage;
class OMaizeSilage;
class OBarleyPeaCloverGrass;
class OCarrots;
class OCloverGrassGrazed1;
class OCloverGrassGrazed2;
class OCloverGrassSilage1;
class OFieldPeas;
class OFieldPeasSilage;
class OFirstYearDanger;
class OGrazingPigs;
class OOats;
class Oats;
class OrchardCrop;
class OFodderbeet;
class OPermanentGrassGrazed;
class OPotatoes;
class OSBarleySilage;
class OSeedGrass1;
class OSeedGrass2;
class OSpringBarley;
class OSpringBarleyExt;
class OSpringBarleyPigs;
class OWinterBarley;
class OWinterBarleyExt;
class OWinterRape;
class OWinterRye;
class OWinterWheatUndersown;
class OWinterWheatUndersownExt;
class PermanentGrassGrazed;
class PermanentGrassLowYield;
class PermanentGrassTussocky;
class PermanentSetAside;
class Potatoes;
class PotatoesIndustry;
class SeedGrass1;
class SeedGrass2;
class SetAside;
class SpringBarley;
class SpringBarleySpr;
class SpringBarleyPTreatment;
class SpringBarleySKManagement;
class SpringBarleyCloverGrass;
class SpringBarleySeed;
class SpringBarleySilage;
class SpringRape;
class Sugarbeet;
class Triticale;
class OTriticale;
class WinterBarley;
class WinterRape;
class WinterRye;
class WinterWheat;
class WWheatPControl;
class WWheatPTreatment;
class WWheatPToxicControl;
class AgroChemIndustryCereal;
class WinterWheatStrigling;
class WinterWheatStriglingSingle;
class WinterWheatStriglingCulm;
class SpringBarleyCloverGrassStrigling;
class SpringBarleyStrigling;
class SpringBarleyStriglingCulm;
class SpringBarleyStriglingSingle;
class MaizeStrigling;
class WinterRapeStrigling;
class WinterRyeStrigling;
class WinterBarleyStrigling;
class FieldPeasStrigling;
class SpringBarleyPeaCloverGrassStrigling;
class YoungForestCrop;
class Hunter;
class OWinterWheat;
class NorwegianPotatoes;
class NorwegianOats;
class NorwegianSpringBarley;
 
class PLWinterWheat;
class PLWinterRape;
class PLWinterBarley;
class PLWinterTriticale;
class PLWinterRye;
class PLSpringWheat;
class PLSpringBarley;
class PLMaize;
class PLMaizeSilage;
class PLPotatoes;
class PLBeet;
class PLFodderLucerne1;
class PLFodderLucerne2;
class PLCarrots;
class PLSpringBarleySpr;
class PLWinterWheatLate;
class PLBeetSpr;
class PLBeans;
 
class NLBeet;
class NLCarrots;
class NLMaize;
class NLPotatoes;
class NLSpringBarley;
class NLWinterWheat;
class NLCabbage;
class NLTulips;
class NLGrassGrazed1;
class NLGrassGrazed1Spring;
class NLGrassGrazed2;
class NLGrassGrazedLast;
class NLPermanentGrassGrazed;
class NLBeetSpring;
class NLCarrotsSpring;
class NLMaizeSpring;
class NLPotatoesSpring;
class NLSpringBarleySpring;
class NLCabbageSpring;
class NLCatchPeaCrop;
 
class DummyCropPestTesting;
 
 
typedef vector<unsigned >polylist;
typedef vector < Hunter* > HunterList;
 
enum TTypeCropClassification {
    tocc_Winter = 0,
    tocc_Spring,
    tocc_Catch,
    tocc_Foobar
};
 
 
typedef enum
{
  tof_ConventionalCattle=0,
  tof_ConventionalPig,
  tof_ConventionalPlant,
  tof_OrganicCattle,
  tof_OrganicPig,
  tof_OrganicPlant,
  tof_PTrialControl,
  tof_PTrialTreatment,
  tof_PTrialToxicControl,
  tof_ConvMarginalJord,
  tof_AgroChemIndustryCerealFarm1, //10
  tof_AgroChemIndustryCerealFarm2,
  tof_AgroChemIndustryCerealFarm3,
  tof_NoPesticideBase,
  tof_NoPesticideNoP,
  tof_UserDefinedFarm1, //15
  tof_UserDefinedFarm2,
  tof_UserDefinedFarm3,
  tof_UserDefinedFarm4,
  tof_UserDefinedFarm5,
  tof_UserDefinedFarm6, //20
  tof_UserDefinedFarm7,
  tof_UserDefinedFarm8,
  tof_UserDefinedFarm9,
  tof_UserDefinedFarm10,
  tof_UserDefinedFarm11,
  tof_UserDefinedFarm12,
  tof_UserDefinedFarm13,
  tof_UserDefinedFarm14,
  tof_UserDefinedFarm15,
  tof_UserDefinedFarm16,
  tof_UserDefinedFarm17,
  tof_UserDefinedFarm18,
  tof_UserDefinedFarm19,
  tof_UserDefinedFarm20,
  tof_UserDefinedFarm21,
  tof_UserDefinedFarm22,
  tof_UserDefinedFarm23,
  tof_UserDefinedFarm24,
  tof_UserDefinedFarm25,
  tof_UserDefinedFarm26,
  tof_UserDefinedFarm27,
  tof_UserDefinedFarm28,
  tof_UserDefinedFarm29,
  tof_UserDefinedFarm30,
  tof_UserDefinedFarm31,
  tof_UserDefinedFarm32,
  tof_UserDefinedFarm33,
  tof_UserDefinedFarm34,
  tof_UserDefinedFarm35,
  tof_OptimisingFarm
}TTypesOfFarm;
 
 
//enums for the OptimisingFarms: toof, tos, tofs, toa, toc, top, tolp, tocv
typedef enum {
    toof_Other = 0,
    toof_Cattle, // 1
    toof_Plant, // 2
    toof_Pig, // 3
    toof_Foobar // Must be in here and the last one as well!
}TTypesOfOptFarms;
 
typedef enum {
    tos_Sand = 0,
    tos_Other, // 1
    tos_Clay, // 2
        tos_Foobar // Must be in here and the last one as well!
}TTypesOfSoils;
 
typedef enum {
    tofs_Business = 0,
    tofs_Private, // 1
        tofs_Foobar // Must be in here and the last one as well!
}TTypesOfFarmSize;
 
typedef enum {
    toa_Horse = 0,
    toa_DCow, // 1
    toa_Suckler,
    toa_DCalf,
    toa_MCalf,
    toa_MCattle,
    toa_Sheep,
    toa_Goat,
    toa_So,
    toa_Finisher,
    toa_Piglet,
    toa_Deer,
    toa_Mink,
    toa_EHen,
    toa_MHen,
    toa_Turkey,
    toa_Goose,
    toa_Duck,
    toa_MDuck,
    toa_Ostrich,
        toa_Foobar // Must be in here and the last one as well!
}TTypesOfAnimals;
 
typedef enum {
    toc_SBarley = 0,
    toc_Oats,  //1
    toc_OSCrops,
    toc_WBarley,
    toc_WWheat,
    toc_WRye, //5
    toc_Triticale,
    toc_SRape,
    toc_WRape,
    toc_OOilseed,
    toc_Peas, //10
    toc_OLSeed,
    toc_GrassSeed,
    toc_Potato,
    toc_PotatoFood,
    toc_SugarBeet, //15
    toc_GrassClover,
    toc_OLSeedCut,
    toc_SCerealSil,
    toc_PeasSil,
    toc_MaizeSil, //20
    toc_WCerealSil,
    toc_SCerealG,
    toc_PerGrassLow,
    toc_PerGrassNorm,
    toc_GrassEnv1, //25
    toc_GrassEnv2,
    toc_GrassRot,
    toc_Setaside,
    toc_Uncult,
    toc_OUncult, //30
    toc_FodderBeet,
    toc_OFodderBeet,
    toc_CloverGrz,
    toc_Veg,
    toc_Fruit,
    toc_FruitTree, //35
    toc_OSpecCrops,
    toc_ChrisTree,
    toc_EnergyFor,
    toc_OTriticale,
    toc_SpringRape,
    toc_Other,
        toc_Foobar // Must be in here and the last one as well!
}TTypesOfCrops;
 
//crop parameters that do not vary with farm type, soil type etc.
typedef enum {
    top_Subsidy = 0,
    top_PriceLM, //1
    top_PriceHerb,
    top_PriceFi,
    top_PriceG,
    top_PriceH,
    top_PriceW,
    top_AlfaHerb,
    top_BetaHerb,
    top_AlfaFi,
    top_BetaFi,
    top_AlfaG,
    top_BetaG,
    top_AlfaH,
    top_BetaH,
    top_AlfaW,
    top_BetaW,
        top_Foobar // Must be in here and the last one as well!
}TTypesOfParameters;
 
typedef enum {
    tolp_AUKey = 0,
    tolp_Nusable, //1
    tolp_FUuKey, //2
        tolp_Foobar // Must be in here and the last one as well!
}TTypesOfLivestockParameters;
 
typedef enum {
    tocv_AreaPercent = 0,
    tocv_AreaHa, //1
    tocv_N,
    tocv_Nt,
    tocv_BIHerb, //2
    tocv_BIFi,
    tocv_BI,
    tocv_Grooming,
    tocv_Hoeing,
    tocv_Weeding,
    tocv_TotalLoss,
    tocv_Response,
    tocv_Income,
    tocv_Costs,
    tocv_GM,
    tocv_Savings,
        tocv_Foobar // Must be in here and the last one as well!
}TTypesOfCropVariables;
 
enum PlantProtectionProducts
{
    ppp_1 = 0,
    ppp_2,
    ppp_3,
    ppp_4,
    ppp_5,
    ppp_6,
    ppp_7,
    ppp_8,
    ppp_9,
    ppp_10,
    ppp_foobar
};
 
enum TTypeOfFarmerGoal {
    tofg_profit = 0,
    tofg_yield,
    tofg_environment,
    tofg_Foobar
};
 
struct pesticiderecord {
    double m_amounts[ppp_foobar];
    bool m_present;
};
 
struct PermCropData {
    TTypesOfVegetation Tov;
    int Pct;
};
 
struct tpct {
    int index;
    int pct;
};
 
struct FarmEvent
{
  bool       m_lock;
  int        m_startday;
  bool       m_first_year;
  long       m_run;
  int        m_todo;
  TTypesOfVegetation m_event;
  TTypesOfVegetation m_next_tov;
  LE        *m_field;
 
  FarmEvent( TTypesOfVegetation a_event, LE *a_field, int a_todo, long a_run,
             bool a_lock, int a_start, bool a_first_year,
             TTypesOfVegetation a_nextcrop )
    {
      m_event = a_event;
      m_field    = a_field;
      m_todo  = a_todo;
      m_run      = a_run;
      m_lock  = a_lock;
      m_startday = a_start;
      m_first_year = a_first_year;
      m_next_tov=a_nextcrop;
    }
};
 
struct farminfo {
    int m_farmref;
    int m_farmtype;
    int m_farmsize;
    int m_farmarable;
    int m_nofields;
    int m_openfields;
    int m_areaopenfields;
    APoint m_farmcentroid;
    APoint m_farmvalid;
    int m_NoHunters;
};
 
 
class HunterInfo
{
public:
    int refID;
    int homeX;
    int homeY;
    vector<int> FarmHuntRef;
    vector<int> CheckedFarms;
 
    ~HunterInfo() {
        FarmHuntRef.resize( 0 );
        CheckedFarms.resize( 0 );
    }
};
 
class Crop
{
protected:
  Farm      *m_farm;
  LE        *m_field;
  FarmEvent *m_ev;
  int        m_first_date;
  int        m_count;
  int        m_last_date;
  int        m_ddegstoharvest;
  //* \brief Contains information on whether this is a winter crop, spring crop, or catch crop that straddles the year boundary (0,1,2)
  int       m_CropClassification;
 
  void SimpleEvent(long a_date, int a_todo, bool a_lock);
 
  void SimpleEvent_(long a_date, int a_todo, bool a_lock, Farm* a_farm, LE* a_field);
 
public:
    virtual ~Crop() {}
    Crop();
    int GetFirstDate( void ) { return m_first_date; }
    virtual bool Do( Farm *a_farm,  LE *a_field, FarmEvent *a_ev );
    void ChooseNextCrop (int a_no_dates);
    //* \brief Get method for m_CropClassification */
    int GetCropClassification() { return m_CropClassification; }
    //* \brief Get method for m_CropClassification */
    void SetCropClassification(int a_classification) { m_CropClassification = a_classification; }
 
};
 
 
// v. similar to PermCropData, but has double instead of int. 
//Used originally for saving Bedriftsmodel (original farm optimization model) type crops in almass type. Also used to store data on biomass_factors
//so changed the name of the member - from Pct to Number
 
    struct AlmassCrop {
        double Number;
        TTypesOfVegetation Tov;
    };
 
class DataForOptimisation {
 
public:
    DataForOptimisation();
 
    //Data at a general level
    void Set_livestockTypes(TTypesOfAnimals livestock_type){m_livestockTypes.push_back(livestock_type);};
    void Set_cropTypes(TTypesOfCrops crop_type){m_cropTypes.push_back(crop_type);};
    void Set_cropTypes_str (string crop_type){m_str_cropTypes.push_back(crop_type);};
    TTypesOfAnimals Get_livestockTypes(int i){return m_livestockTypes[i];};
    string Get_cropTypes_str (int i) {return m_str_cropTypes[i];};
    TTypesOfCrops Get_cropTypes(int i) {return m_cropTypes[i];};
 
    //Individual data for farms (vector size is no_farms x given_Foobar)
    void Set_livestockNumber(int a_number){m_livestockNumbers.push_back(a_number);}; 
    void Set_cropArea(double a_area){m_cropAreas.push_back(a_area);};
    int Get_livestockNumber(int index){return m_livestockNumbers[index];}; 
    int Get_livestockNumbersSize(){return (int)m_livestockNumbers.size();};
    double Get_cropArea(int index){return m_cropAreas[index];};
    int Get_cropAreasSize(){return (int)m_cropAreas.size();};
 
    //Data for farms
    TTypesOfOptFarms Get_farmType (int a_almass_no);
    void Set_winterMax (int a_value, int i){m_winterMax[i]=a_value;};
    int Get_winterMax (int i) {return m_winterMax[i];};
 
    //Data for livestock
    void Set_livestockParameter(double a_value, int i){m_livestockParameters[i]=a_value;};
    double Get_livestockParameter(int i){return m_livestockParameters[i];};
 
    //Data for crops
    void Set_cropParameter (double a_value, int i){m_cropParameters[i]=a_value;};
    double Get_cropParameter (int i) {return m_cropParameters[i];};
 
    void Set_alfa (double a_value, int i){m_alfa[i]=a_value;};
    double Get_alfa (int i) {return m_alfa[i];};
    void Set_beta1 (double a_value, int i){m_beta1[i]=a_value;};
    double Get_beta1 (int i) {return m_beta1[i];};
    void Set_beta2 (double a_value, int i){m_beta2[i]=a_value;};
    double Get_beta2 (int i) {return m_beta2[i];};
    void Set_Nnorm (double a_value, int i){m_Nnorm[i]=a_value;};
    double Get_Nnorm (int i) {return m_Nnorm[i];};
 
 
    void Set_fixed (string a_value, int i){
        if(a_value=="yes" || a_value=="YES" || a_value=="Yes" || a_value=="1"){m_fixed[i]=true;}
        else {m_fixed[i]=false;}
    };
    bool Get_fixed (int i) {return m_fixed[i];};
    void Set_fodder (string a_value, int i){
        if(a_value=="yes" || a_value=="YES" || a_value=="Yes" || a_value=="1"){m_fodder[i]=true;}
        else {m_fodder[i]=false;}
    };
    bool Get_fodder (int i) {return m_fodder[i];};
    void Set_FUKey (double a_value, int i){m_FUKey[i]=a_value;};
    double Get_FUKey (int i) {return m_FUKey[i];};
 
    void Set_sellingPrice (double a_value, int i){m_sellingPrice[i]=a_value;};
    double Get_sellingPrice (int i) {return m_sellingPrice[i];};
    void Set_sellingPrice_lastyr (double a_value, int i){m_sellingPrice_lastyr[i]=a_value;};
    double Get_sellingPrice_lastyr (int i) {return m_sellingPrice_lastyr[i];};
 
    void Set_rotationMax (double a_value, int i){m_rotationMax[i]=a_value;};
    double Get_rotationMax (int i) {return m_rotationMax[i];};
    void Set_rotationMin (double a_value, int i){m_rotationMin[i]=a_value;};
    double Get_rotationMin (int i) {return m_rotationMin[i];};
 
 
    //versions for almass crops
    void Set_biomass_factor (double a_value, int i){m_biomass_factors[i] = a_value;};
    double Get_biomass_factor (int i) { return m_biomass_factors[i];} 
 
    void Set_cropTypes_almass(TTypesOfVegetation crop_type){m_cropTypes_almass.push_back(crop_type);};
    TTypesOfVegetation Get_cropTypes_almass (int i) {return m_cropTypes_almass[i];};
    int Get_cropTypes_almass_size (){return (int)m_cropTypes_almass.size();};
    void Set_cropTypes_almass_str (string crop_type){m_str_cropTypes_almass.push_back(crop_type);};
    string Get_cropTypes_almass_str (int i) {return m_str_cropTypes_almass[i];};
 
    void Set_noCrops (int no) {m_noCrops = no;};
    int Get_noCrops (){return m_noCrops;};
 
    void Set_emaize_price (double a_value){m_energy_maize_price.push_back(a_value);};
    double Get_emaize_price (int i){return m_energy_maize_price[i];};
 
    class FarmData{
    public:
        int md_almass_no;
        TTypesOfOptFarms md_farmType;
        TTypesOfSoils md_soilType;
        TTypesOfFarmSize md_farmSize;
        int md_farmRealID;
        int md_soilSubType;
    };
 
    vector<FarmData*>m_farm_data;
 
 
protected:
 //called in the constructor
    void InitializeVector(vector<double>&vector);
    int m_noCrops; //how many crops will be optimised - the number is taken from one of the input files; it has to be the same in all input files with crop data!
 
//I. Data at a general level - changed to config variables
 
//II. Data for farms
 
    vector<string>m_str_cropTypes; //used in output function
    vector<TTypesOfCrops>m_cropTypes;
    //for almass crop types
    vector<string>m_str_cropTypes_almass;
    vector<TTypesOfVegetation>m_cropTypes_almass;
    vector<TTypesOfAnimals>m_livestockTypes;
    vector<double>m_cropAreas;
    vector<int>m_livestockNumbers;
 
    vector<int>m_winterMax;
 
//III. Data for livestock
    vector<double>m_livestockParameters; //full list of the parameters - enum declaration (TTypesOfLivestockParameters)
 
//IV. Data for crops
    //1. parameters that do not vary with farm type, soil type etc. (number of parameters = top_Foobar !)
        vector<double>m_cropParameters; //full list of the parameters - enum declaration (enum TTypesOfParameters)
    //2. parameters that vary with a soil type
        vector<double>m_alfa;
        vector<double>m_beta1;
        vector<double>m_beta2;
        vector<double>m_Nnorm;
        vector<double>m_biomass_factors;
 
    //3. parameters that vary with a farm type
        vector<bool>m_fixed;
        vector<bool>m_fodder;
        vector<double>m_FUKey;
    //4. parameters that vary with a farm and soil type
        vector<double>m_sellingPrice;
        vector<double>m_sellingPrice_lastyr;
    //5. parameters that vary with a farm type, farm size and a soil type
        vector<double>m_rotationMax;
        vector<double>m_rotationMin;
 
    //6. Energy maize runs
        vector<double>m_energy_maize_price;
 
};
 
class Farm
{
public:
    // Management() will use the global date.
    virtual void Management( void );
 
    // InitiateManagement() must be called after all the fields have
    // been added to the farm.
    virtual void InitiateManagement( void );
 
    void     AddField( LE* a_newfield );
    void     RemoveField( LE* a_field );
    Farm( FarmManager* a_manager );
    virtual ~Farm( void );
    void SetFarmNumber( int a_farm_num ) { m_farm_num = a_farm_num; }
    int  GetFarmNumber( void ) { return m_farm_num; }
    //TTypesOfVegetation TranslateCropCodes(std::string& str); 19.03.13 - moved to farm manager
    virtual bool Spraying_herbicides(TTypesOfVegetation){return true; };
    virtual bool Spraying_fungins(TTypesOfVegetation){return true; };
    virtual double Prob_multiplier (){return 1;};
    void Assign_rotation(vector<TTypesOfVegetation>a_new_rotation);
 
    polylist* ListOpenFields( int a_openness ); //14.01.13
    void Centroids();
    int GetNoFields() { return (int) m_fields.size(); }
    int GetNoOpenFields(int a_openness);
    int GetAreaOpenFields(int a_openness);
    APoint GetValidCoords() { APoint pt;  pt.m_x = m_fields[0]->GetValidX(); pt.m_y = m_fields[0]->GetValidY(); return pt; }
    int GetMaxOpenness()
    {
        int op = 0;
        for (int i = 0; i < m_fields.size(); i++)
        {
            int openness = m_fields[i]->GetOpenness();
            if (openness > op) op = openness;
        }
        return op;
    }
 
  // And (*sigh*) the crop treatment functions... :-)
  virtual bool SleepAllDay( LE *a_field, double a_user, int a_days );
  virtual bool AutumnPlough( LE *a_field, double a_user, int a_days );
  virtual bool StubblePlough(LE *a_field, double a_user, int a_days);
  virtual bool StubbleCultivatorHeavy(LE *a_field, double a_user, int a_days);
  virtual bool AutumnHarrow( LE *a_field, double a_user, int a_days );
  virtual bool AutumnRoll( LE *a_field, double a_user, int a_days );
  virtual bool PreseedingCultivator(LE *a_field, double a_user, int a_days);
  virtual bool PreseedingCultivatorSow(LE *a_field, double a_user, int a_days);
  virtual bool AutumnSow( LE *a_field, double a_user, int a_days );
  virtual bool WinterPlough( LE *a_field, double a_user, int a_days );
  virtual bool DeepPlough( LE *a_field, double a_user, int a_days );
  virtual bool SpringPlough( LE *a_field, double a_user, int a_days );
  virtual bool SpringHarrow( LE *a_field, double a_user, int a_days );
  virtual bool SpringRoll( LE *a_field, double a_user, int a_days );
  virtual bool SpringSow( LE *a_field, double a_user, int a_days );
  virtual bool SpringSowWithFerti(LE *a_field, double a_user, int a_days);
  virtual bool HerbicideTreat( LE *a_field, double a_user, int a_days );
  virtual bool GrowthRegulator( LE *a_field, double a_user, int a_days );
  virtual bool FungicideTreat( LE *a_field, double a_user, int a_days );
  virtual bool InsecticideTreat( LE *a_field, double a_user, int a_days );
  virtual bool ProductApplication(LE *a_field, double a_user, int a_days, double a_applicationrate, PlantProtectionProducts a_ppp);
  virtual bool ProductApplication_DateLimited(LE * a_field, double, int, double a_applicationrate, PlantProtectionProducts a_ppp);
  virtual bool Molluscicide( LE *a_field, double a_user, int a_days );
  virtual bool RowCultivation( LE *a_field, double a_user, int a_days );
  virtual bool Strigling( LE *a_field, double a_user, int a_days );
  virtual bool StriglingSow( LE *a_field, double a_user, int a_days );
  virtual bool StriglingHill(LE *a_field, double a_user, int a_days);
  virtual bool HillingUp( LE *a_field, double a_user, int a_days );
  virtual bool Water( LE *a_field, double a_user, int a_days );
  virtual bool Swathing( LE *a_field, double a_user, int a_days );
  virtual bool Harvest(LE *a_field, double a_user, int a_days);
  virtual bool HarvestLong(LE *a_field, double a_user, int a_days);
  virtual bool CattleOut(LE *a_field, double a_user, int a_days);
  virtual bool CattleOutLowGrazing( LE *a_field, double a_user, int a_days );
  virtual bool CattleIsOut( LE *a_field, double a_user, int a_days, int a_max );
  virtual bool CattleIsOutLow( LE *a_field, double a_user, int a_days, int a_max );
  virtual bool PigsOut( LE *a_field, double a_user, int a_days );
  virtual bool PigsAreOut( LE *a_field, double a_user, int a_days );
  virtual bool PigsAreOutForced( LE *a_field, double a_user, int a_days );
  virtual bool CutToHay( LE *a_field, double a_user, int a_days );
  virtual bool CutWeeds( LE *a_field, double a_user, int a_days );
  virtual bool CutToSilage( LE *a_field, double a_user, int a_days );
  virtual bool CutOrch( LE *a_field, double a_user, int a_days ); //added 27.08.12
  virtual bool StrawChopping( LE *a_field, double a_user, int a_days );
  virtual bool HayTurning( LE *a_field, double a_user, int a_days );
  virtual bool HayBailing( LE *a_field, double a_user, int a_days );
  virtual bool BurnStrawStubble( LE *a_field, double a_user, int a_days );
  virtual bool StubbleHarrowing( LE *a_field, double a_user, int a_days );
  virtual bool FP_NPKS( LE *a_field, double a_user, int a_days );
  virtual bool FP_NPK( LE *a_field, double a_user, int a_days );
  virtual bool FP_PK( LE *a_field, double a_user, int a_days );
  virtual bool FP_LiquidNH3( LE *a_field, double a_user, int a_days );
  virtual bool FP_Slurry( LE *a_field, double a_user, int a_days );
  virtual bool FP_ManganeseSulphate( LE *a_field, double a_user, int a_days );
  virtual bool FP_AmmoniumSulphate(LE *a_field, double a_user, int a_days);
  virtual bool FP_Manure( LE *a_field, double a_user, int a_days );
  virtual bool FP_GreenManure( LE *a_field, double a_user, int a_days );
  virtual bool FP_Sludge( LE *a_field, double a_user, int a_days );
  virtual bool FP_RSM(LE *a_field, double a_user, int a_days);
  virtual bool FP_Calcium(LE *a_field, double a_user, int a_days);
  virtual bool FA_NPKS(LE *a_field, double a_user, int a_days);
  virtual bool FA_NPK( LE *a_field, double a_user, int a_days );
  virtual bool FA_PK( LE *a_field, double a_user, int a_days );
  virtual bool FA_Slurry( LE *a_field, double a_user, int a_days );
  virtual bool FA_ManganeseSulphate(LE *a_field, double a_user, int a_days);
  virtual bool FA_AmmoniumSulphate( LE *a_field, double a_user, int a_days );
  virtual bool FA_Manure( LE *a_field, double a_user, int a_days );
  virtual bool FA_GreenManure( LE *a_field, double a_user, int a_days );
  virtual bool FA_Sludge( LE *a_field, double a_user, int a_days );
  virtual bool FA_RSM(LE *a_field, double a_user, int a_days);
  virtual bool FA_Calcium(LE *a_field, double a_user, int a_days);
  virtual bool Biocide(LE *a_field, double a_user, int a_days);
  virtual bool BedForming(LE *a_field, double a_user, int a_days);
  virtual bool ShallowHarrow(LE *a_field, double a_user, int a_days);
  virtual bool HeavyCultivatorAggregate(LE *a_field, double a_user, int a_days);
  virtual bool FlowerCutting(LE *a_field, double a_user, int a_days);
  virtual bool BulbHarvest(LE *a_field, double a_user, int a_days);
  virtual bool StrawCovering(LE *a_field, double a_user, int a_days);
  virtual bool StrawRemoval(LE *a_field, double a_user, int a_days);
  
  // User functions for the treatment steps:
  void AddNewEvent( TTypesOfVegetation a_event, long a_date,
            LE *a_field, int a_todo, long a_num,
            bool a_lock, int a_start,
            bool a_first_year, TTypesOfVegetation a_crop );
  bool DoIt(double a_probability);
  bool DoIt_prob(double a_probability);
  TTypesOfFarm  GetType( void ) { return m_farmtype; }
  int GetArea(void);
  int GetTotalArea(void);
  double GetAreaDouble(void);
  bool IsStockFarmer( void ) { return m_stockfarmer; }
  virtual void MakeStockFarmer( void ) { m_stockfarmer = true; }
  int GetIntensity( void ) { return m_intensity; }
  APoint GetCentroids() { APoint pt; pt.m_x = m_farm_centroidx; pt.m_y = m_farm_centroidy; return pt; }
  TTypesOfVegetation GetPreviousCrop(int a_index) {
      int ind = a_index - 1;
      if (ind < 0) ind = (int)m_rotation.size() - 1;
      return m_rotation[ind];
  }
  TTypesOfVegetation GetCrop(int a_index) {
      return m_rotation[a_index];
  }
  TTypesOfVegetation GetNextCrop(int a_index) {
      int ind = a_index + 1;
      if (ind >= (int)m_rotation.size()) ind = ind - (int)m_rotation.size();
      return m_rotation[ind];
  }
  void AddHunter(Hunter* a_hunter) {
      m_HuntersList.push_back( a_hunter );
  }
  void RemoveHunter( Hunter* a_hunter ) {
      for (int h = 0; h < m_HuntersList.size(); h++) {
          if (m_HuntersList[ h ] == a_hunter) {
              m_HuntersList.erase( m_HuntersList.begin() + h );
          }
      }
  }
 
protected:
    FarmManager* m_OurManager;
    LowPriority< FarmEvent* >  m_queue;
    vector< LE* >              m_fields;
    vector<TTypesOfVegetation> m_rotation;
    vector<PermCropData>        m_PermCrops;
    TTypesOfFarm  m_farmtype;
    HunterList m_HuntersList;
    bool m_stockfarmer;
    int m_farm_num;
    int m_rotation_sync_index;
    int m_intensity;
    int GetFirstDate( TTypesOfVegetation a_tov );
    int GetNextCropStartDate( LE* a_field,TTypesOfVegetation &a_curr_veg );
    virtual int GetFirstCropIndex( TTypesOfLandscapeElement a_type );
    virtual int GetNextCropIndex( int a_rot_index );
    virtual void HandleEvents( void );
    bool LeSwitch( FarmEvent *ev );
    void CheckRotationManagementLoop( FarmEvent *ev );
    void ReadRotation(std::string fname);
 
    void AssignPermanentCrop(TTypesOfVegetation tov, int pct); //MOVED FROM THE  USER DEFINED FARM
    int InvIntPartition(vector<tpct>* items, int target);
    int m_farm_centroidx;
    int m_farm_centroidy;
 
 
  // The program function objects for the individual crops.
  // Remember to add these into the Farm class con- and destructor too.
  Carrots                 *m_carrots;
  BroadBeans              *m_broadbeans;
  FodderGrass             *m_foddergrass;
  CloverGrassGrazed1      *m_CGG1;
  CloverGrassGrazed2      *m_CGG2;
  FieldPeas               *m_fieldpeas;
  FieldPeasSilage         *m_fieldpeassilage;
  Fodderbeet              *m_fodderbeet;
  Sugarbeet               *m_sugarbeet;
  OFodderbeet             *m_ofodderbeet;
  Maize                   *m_maize;
  MaizeSilage             *m_maizesilage;
  OMaizeSilage            *m_omaizesilage;
  OBarleyPeaCloverGrass   *m_OBarleyPCG;
  OCarrots                *m_ocarrots;
  OCloverGrassGrazed1     *m_OCGG1;
  OCloverGrassGrazed2     *m_OCGG2;
  OCloverGrassSilage1     *m_OCGS1;
  OFieldPeas          *m_ofieldpeas;
  OFieldPeasSilage    *m_ofieldpeassilage;
  OFirstYearDanger        *m_ofirstyeardanger;
  OGrazingPigs            *m_ograzingpigs;
  OrchardCrop             *m_orchardcrop;
  Oats                    *m_oats;
  OOats                   *m_ooats;
  OPermanentGrassGrazed   *m_opermgrassgrazed;
  OPotatoes               *m_opotatoes;
  OSeedGrass1              *m_oseedgrass1;
  OSeedGrass2              *m_oseedgrass2;
  OSpringBarley           *m_ospringbarley;
  OSpringBarleyExt        *m_ospringbarleyext;
  OSpringBarleyPigs       *m_ospringbarleypigs;
  OSBarleySilage          *m_osbarleysilage;
  OTriticale               *m_otriticale;
  OWinterBarley           *m_owinterbarley;
  OWinterBarleyExt        *m_owinterbarleyext;
  OWinterRape             *m_owinterrape;
  OWinterRye              *m_owinterrye;
  OWinterWheatUndersown   *m_owinterwheatundersown;
  OWinterWheat            *m_owinterwheat;
  OWinterWheatUndersownExt *m_owinterwheatundersownext;
  PermanentGrassGrazed    *m_permgrassgrazed;
  PermanentGrassLowYield  *m_permgrasslowyield;
  PermanentGrassTussocky  *m_permgrasstussocky;
  PermanentSetAside       *m_permanentsetaside;
  Potatoes                *m_potatoes;
  PotatoesIndustry        *m_potatoesindustry;
  SeedGrass1              *m_seedgrass1;
  SeedGrass2              *m_seedgrass2;
  SetAside                *m_setaside;
  SpringBarley            *m_springbarley;
  SpringBarleySpr         *m_springbarleyspr;
  SpringBarleySKManagement *m_springbarleyskmanagement;
  SpringBarleyPTreatment  *m_springbarleyptreatment;
  SpringBarleyCloverGrass *m_sbarleyclovergrass;
  SpringBarleySeed        *m_springbarleyseed;
  SpringBarleySilage      *m_springbarleysilage;
  SpringRape              *m_springrape;
  Triticale               *m_triticale;
  WinterBarley            *m_winterbarley;
  WinterRape              *m_winterrape;
  WinterRye               *m_winterrye;
  WinterWheat             *m_winterwheat;
  WWheatPControl          *m_wwheatpcontrol;
  WWheatPToxicControl     *m_wwheatptoxiccontrol;
  WWheatPTreatment        *m_wwheatptreatment;
  AgroChemIndustryCereal          *m_agrochemindustrycereal;
  WinterWheatStrigling    *m_winterwheatstrigling;
  WinterWheatStriglingCulm    *m_winterwheatstriglingculm;
  WinterWheatStriglingSingle    *m_winterwheatstriglingsingle;
  SpringBarleyCloverGrassStrigling *m_springbarleyclovergrassstrigling;
  SpringBarleyStrigling   *m_springbarleystrigling;
  SpringBarleyStriglingCulm   *m_springbarleystriglingculm;
  SpringBarleyStriglingSingle   *m_springbarleystriglingsingle;
  MaizeStrigling          *m_maizestrigling;
  WinterRapeStrigling     *m_winterrapestrigling;
  WinterRyeStrigling      *m_winterryestrigling;
  WinterBarleyStrigling   *m_winterbarleystrigling;
  FieldPeasStrigling      *m_fieldpeasstrigling;
  SpringBarleyPeaCloverGrassStrigling *m_springbarleypeaclovergrassstrigling;
  YoungForestCrop *m_youngforest;
  NorwegianPotatoes * m_norwegianpotatoes;
  NorwegianOats * m_norwegianoats;
  NorwegianSpringBarley* m_norwegianspringbarley;
 
  PLWinterWheat         *m_plwinterwheat;
  PLWinterRape          *m_plwinterrape;
  PLWinterBarley            *m_plwinterbarley;
  PLWinterTriticale         *m_plwintertriticale;
  PLWinterRye           *m_plwinterrye;
  PLSpringWheat         *m_plspringwheat;
  PLSpringBarley            *m_plspringbarley;
  PLMaize           *m_plmaize;
  PLMaizeSilage         *m_plmaizesilage;
  PLPotatoes            *m_plpotatoes;
  PLBeet                *m_plbeet;
  PLFodderLucerne1      *m_plfodderlucerne1;
  PLFodderLucerne2      *m_plfodderlucerne2;
  PLCarrots             *m_plcarrots;
  PLSpringBarleySpr         *m_plspringbarleyspr;
  PLWinterWheatLate         *m_plwinterwheatlate;
  PLBeetSpr             *m_plbeetspr;
  PLBeans               *m_plbeans;
 
  NLBeet                *m_nlbeet;
  NLCarrots             *m_nlcarrots;
  NLMaize               *m_nlmaize;
  NLPotatoes            *m_nlpotatoes;
  NLSpringBarley        *m_nlspringbarley;
  NLWinterWheat         *m_nlwinterwheat;
  NLCabbage             *m_nlcabbage;
  NLTulips              *m_nltulips;
  NLGrassGrazed1                *m_nlgrassgrazed1;
  NLGrassGrazed1Spring              *m_nlgrassgrazed1spring;
  NLGrassGrazed2                *m_nlgrassgrazed2;
  NLGrassGrazedLast             *m_nlgrassgrazedlast;
  NLPermanentGrassGrazed                *m_nlpermanentgrassgrazed;
  NLBeetSpring              *m_nlbeetspring;
  NLCarrotsSpring               *m_nlcarrotsspring;
  NLMaizeSpring             *m_nlmaizespring;
  NLPotatoesSpring          *m_nlpotatoesspring;
  NLSpringBarleySpring      *m_nlspringbarleyspring;
  NLCabbageSpring               *m_nlcabbagespring;
  NLCatchPeaCrop                *m_nlcatchpeacrop;
 
  DummyCropPestTesting  *m_dummycroppesttesting;
 };
 
 
class ConventionalCattle : public Farm
{
public:
  ConventionalCattle( FarmManager* a_manager );
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class ConventionalPig : public Farm
{
public:
    ConventionalPig(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class ConventionalPlant : public Farm
{
public:
    ConventionalPlant(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicPlant : public Farm
{
public:
    OrganicPlant(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicPig : public Farm
{
public:
    OrganicPig(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class OrganicCattle : public Farm
{
public:
    OrganicCattle(FarmManager* a_manager);
//protected:
//  virtual TTypesOfVegetation GetFirstCrop( void );
//  virtual TTypesOfVegetation GetNextCrop( TTypesOfVegetation a_veg );
};
 
class PesticideTrialControl : public Farm
{
public:
    PesticideTrialControl(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
class PesticideTrialToxicControl : public Farm
{
public:
    PesticideTrialToxicControl(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
class PesticideTrialTreatment : public Farm
{
public:
    PesticideTrialTreatment(FarmManager* a_manager);
  virtual void MakeStockFarmer( void ) { m_stockfarmer = false; }
};
 
 
 
class ConvMarginalJord : public Farm
{
public:
    ConvMarginalJord(FarmManager* a_manager);
};
 
 
class AgroChemIndustryCerealFarm1 : public Farm
{
public:
    AgroChemIndustryCerealFarm1(FarmManager* a_manager);
};
 
class AgroChemIndustryCerealFarm2 : public Farm
{
public:
    AgroChemIndustryCerealFarm2(FarmManager* a_manager);
};
 
class AgroChemIndustryCerealFarm3 : public Farm
{
public:
    AgroChemIndustryCerealFarm3(FarmManager* a_manager);
};
 
class NoPesticideBaseFarm : public Farm
{
public:
    NoPesticideBaseFarm(FarmManager* a_manager);
};
 
class NoPesticideNoPFarm : public Farm
{
public:
    NoPesticideNoPFarm(FarmManager* a_manager);
};
 
class UserDefinedFarm : public Farm
{
public:
    UserDefinedFarm(const char* fname, FarmManager* a_manager);
protected:
    virtual void InitiateManagement( void );
    //void AssignPermanentCrop(TTypesOfVegetation tov, int pct); //MOVED TO THE FARM CLASS
    //int InvIntPartition(vector<tpct>* items, int target);
    //void TranslateBitsToFields(int bits, vector<LE*> &f_cpy, TTypesOfVegetation tov);
};
 
class UserDefinedFarm1 : public Farm
{
public:
    UserDefinedFarm1(FarmManager* a_manager);
};
 
class UserDefinedFarm2 : public Farm
{
public:
    UserDefinedFarm2(FarmManager* a_manager);
};
 
class UserDefinedFarm3 : public Farm
{
public:
    UserDefinedFarm3(FarmManager* a_manager);
};
 
class UserDefinedFarm4 : public Farm
{
public:
    UserDefinedFarm4(FarmManager* a_manager);
};
 
class UserDefinedFarm5 : public Farm
{
public:
    UserDefinedFarm5(FarmManager* a_manager);
};
 
class UserDefinedFarm6 : public Farm
{
public:
    UserDefinedFarm6(FarmManager* a_manager);
};
 
class UserDefinedFarm7 : public Farm
{
public:
    UserDefinedFarm7(FarmManager* a_manager);
};
 
class UserDefinedFarm8 : public Farm
{
public:
    UserDefinedFarm8(FarmManager* a_manager);
};
 
class UserDefinedFarm9 : public Farm
{
public:
    UserDefinedFarm9(FarmManager* a_manager);
};
 
class UserDefinedFarm10 : public Farm
{
public:
    UserDefinedFarm10(FarmManager* a_manager);
};
 
class UserDefinedFarm11 : public Farm
{
public:
    UserDefinedFarm11(FarmManager* a_manager);
};
 
class UserDefinedFarm12 : public Farm
{
public:
    UserDefinedFarm12(FarmManager* a_manager);
};
 
class UserDefinedFarm13 : public Farm
{
public:
    UserDefinedFarm13(FarmManager* a_manager);
};
 
class UserDefinedFarm14 : public Farm
{
public:
    UserDefinedFarm14(FarmManager* a_manager);
};
 
class UserDefinedFarm15 : public Farm
{
public:
    UserDefinedFarm15(FarmManager* a_manager);
};
 
class UserDefinedFarm16 : public Farm
{
public:
    UserDefinedFarm16(FarmManager* a_manager);
};
 
class UserDefinedFarm17 : public Farm
{
public:
    UserDefinedFarm17(FarmManager* a_manager);
};
 
class UserDefinedFarm18 : public UserDefinedFarm
{
public:
    UserDefinedFarm18(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm19 : public UserDefinedFarm
{
public:
    UserDefinedFarm19(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm20 : public UserDefinedFarm
{
public:
    UserDefinedFarm20(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm21 : public UserDefinedFarm
{
public:
    UserDefinedFarm21(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm22 : public UserDefinedFarm
{
public:
    UserDefinedFarm22(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm23 : public UserDefinedFarm
{
public:
    UserDefinedFarm23(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm24 : public UserDefinedFarm
{
public:
    UserDefinedFarm24(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm25 : public UserDefinedFarm
{
public:
    UserDefinedFarm25(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm26 : public UserDefinedFarm
{
public:
    UserDefinedFarm26(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm27 : public UserDefinedFarm
{
public:
    UserDefinedFarm27(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm28 : public UserDefinedFarm
{
public:
    UserDefinedFarm28(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm29 : public UserDefinedFarm
{
public:
    UserDefinedFarm29(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm30 : public UserDefinedFarm
{
public:
    UserDefinedFarm30(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm31 : public UserDefinedFarm
{
public:
    UserDefinedFarm31(const char* fname, FarmManager* a_manager);
};
 
class UserDefinedFarm32 : public UserDefinedFarm
{
public:
    UserDefinedFarm32(const char* fname,FarmManager* a_manager);
};
 
class UserDefinedFarm33 : public UserDefinedFarm
{
public:
    UserDefinedFarm33(const char* fname,FarmManager* a_manager);
};
 
class UserDefinedFarm34 : public UserDefinedFarm
{
public:
    UserDefinedFarm34(const char* fname,FarmManager* a_manager);
};
 
class UserDefinedFarm35 : public UserDefinedFarm
{
public:
    UserDefinedFarm35(const char* fname,FarmManager* a_manager);
};
 
 
 
//--------------------------------------------------------------------------------------------
//--------------------------OptimisingFarm----------------------------------------------------
//--------------------------------------------------------------------------------------------
 
class Livestock {
    public:
        Livestock(TTypesOfAnimals a_animalType, int a_number);
        TTypesOfAnimals m_animalType;
        int m_number;
        double m_NanimUsable;
        double m_FUdemand;
    };
 
class CropOptimised {
    public:
        CropOptimised(TTypesOfCrops a_cropType, double a_initialArea);
        CropOptimised(TTypesOfVegetation a_cropType, double a_initialArea); 
        CropOptimised(); //another constructor - for the fake crop
 
        double m_initialArea;
        TTypesOfCrops m_cropType;
        TTypesOfVegetation m_cropType_almass;
 
    //parameters: here saved - to make it easier to read them (they are needed very often)
        double m_rotationMax;
        double m_rotationMin;
 
    //optimised variables
        double m_n;
        double m_nt;
        double m_optimalN;
 
        double m_benefit;
        double m_resp;
        double m_BIHerb;
        double m_BIFi;
        double m_BI;
        double m_grooming;
        double m_hoeing; 
        double m_weeding;
        double m_lossHerb;
        double m_lossFi;
        double m_totalLoss;
        double m_costs_ha;
        double m_income_ha;
        double m_GM;
        double m_savings; 
        double m_GM_Savings;
        double m_areaPercent;
        double m_areaVariable;
        double m_area_ha;
};
 
class FarmManager
{
public:
    FarmManager();
    ~FarmManager();
    void FarmManagement();
    void InitiateManagement( void );
    void AddField(int a_OwnerIndex, LE* a_newland, int a_Owner);
    void RemoveField(int a_OwnerIndex, LE* a_field);
    int ConnectFarm(int a_owner);
    TTypesOfVegetation TranslateCropCodes(std::string& str); //moved from farm
    void DumpFarmAreas();
    void DumpFarmrefs();
    void InitFarms();
    void Save_diff_farm_types_areas();
    int GetFarmTotalSize(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetTotalArea());
    }
    int GetFarmArableSize(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetArea());
    }
    TTypesOfFarm GetFarmType(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetType());
    }
    int GetFarmNoFields(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetNoFields());
    }
    APoint GetFarmValidCoords(int a_farmref)
    {
        return (GetFarmPtr(a_farmref)->GetValidCoords());
    }
    
    int GetFarmNoOpenFields(int a_farmref, int a_openness)
    {
        return (GetFarmPtr(a_farmref)->GetNoOpenFields(a_openness));
    }
 
    int GetFarmAreaOpenFields(int a_farmref, int a_openness)
    {
        return (GetFarmPtr(a_farmref)->GetAreaOpenFields(a_openness));
    }
 
    Farm* GetFarmPtr( int a_owner ) {
        for (unsigned int i = 0; i < m_farms.size( ); i++) {
            if (a_owner == m_farms[ i ]->GetFarmNumber( )) {
                return m_farms[ i ];
            }
        }
        g_msg->Warn( "FarmManager::GetFarmPtr - missing farm ref", a_owner );
        exit( 92 );
    }
 
    Farm* GetFarmPtrIndex( int a_index) {
                return m_farms[ a_index ];
    }
    int GetRandomFarmRefnum() { return m_farms[random((int)m_farms.size())]->GetFarmNumber(); }
    void CalcCentroids() { for (unsigned int i = 0; i < m_farms.size(); i++) m_farms[i]->Centroids(); }
    bool InIllegalList( int a_farm_ref, vector<int> * a_farmlist );
    void AddToIllegalList( int a_farm_ref, vector<int> * a_farmlist );
    int FindClosestFarm(HunterInfo a_hinfo, vector<int> *a_farmlist);
    //int FindClosestFarmProb(HunterInfo a_hinfo, vector<int> *a_farmlist);
    int FindClosestFarmOpenness( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness );
    int FindClosestFarmOpennessProb( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness );
    int FindClosestFarmOpennessProbSmallIsBest( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness, vector<int> * a_farmsizelist );
    int FindClosestFarmOpennessProbNearRoostIsBest( HunterInfo a_hinfo, vector<int> * a_farmlist, int a_openness, vector<APoint> * a_farmsizelist );
    int FindFarmWithRandom(vector<int> * a_farmlist);
    int FindFarmWithOpenness(vector<int> * a_farmlist, int a_openness);
    int FindOpennessFarm(int a_openness);
    bool CheckOpenness( int a_openness, int a_ref );
    APoint GetFarmCentroid(int a_farmref)
    {
        for (unsigned int i = 0; i < m_farms.size(); i++)
        {
            if (a_farmref == m_farms[i]->GetFarmNumber())
            {
                return m_farms[i]->GetCentroids();
            }
        }
        g_msg->Warn("FarmManager::GetFarmCentroid - missing farm ref", a_farmref);
        exit(92);
    }
    bool IsDuplicateRef(int a_ref, HunterInfo* a_hinfo);
    double GetSpilledGrain();
    double GetSpilledMaize();
    void SetSpilledGrain( bool a_spilledgrain ) {
        m_SpilledGrain = a_spilledgrain;
    }
//for the decision making
    void FindNeighbours();
    double GetDD (void){return daydegrees;}; 
    void SetDD (double a_dd){daydegrees = a_dd;};
    double Get_cropTotals (int i) {return m_cropTotals[i];};
    void Add_to_cropTotals (int i, double value){m_cropTotals[i] += value;};
    void Set_cropTotals (int i, double value){m_cropTotals[i] = value;};
    int Get_cropTotals_size (){return (int)m_cropTotals.size();};
    void ActualProfit();
    void ChooseDecisionMode_for_farms();
    void Save_last_years_crops_for_farms();
    void PrintDecModes_counts();
    void PrintFinalResults();
    void Switch_rotation();
    TTypesOfVegetation Get_crops_summary_BIs_tov (int i){return m_crops_summary_BIs[i].Tov;};
    void Set_crops_summary_BIs_herb(int i, double BIherb){m_crops_summary_BIs[i].BIherb += BIherb;};
    void Set_crops_summary_BIs_fi(int i, double BIfi){m_crops_summary_BIs[i].BIfi += BIfi;};
    void Set_crops_summary_BIs (int i, double BI){m_crops_summary_BIs[i].BI += BI;};
    void Set_cropTotals_sum(int i, double crop_area){m_cropTotals_sum[i] += crop_area;};
    void Set_cropTotals_plant_sum(int i, double crop_area){m_cropTotals_plant_sum[i] += crop_area;};
    void Set_cropTotals_pig_sum(int i, double crop_area){m_cropTotals_pig_sum[i] += crop_area;};
    void Set_cropTotals_cattle_sum(int i, double crop_area){m_cropTotals_cattle_sum[i] += crop_area;};
    void Set_cropTotals_other_sum(int i, double crop_area){m_cropTotals_other_sum[i] += crop_area;};
 
    void Set_crops_fertilizer (int i, double fert){m_crops_fertilizer[i] += fert;};
    void Set_crops_fertilizer_trade (int i, double fert_trade){m_crops_fertilizer_trade[i] += fert_trade;};
 
 
    TTypesOfOptFarms TranslateFarmCodes(string &str);
    TTypesOfSoils TranslateSoilCodes(string &str);
    TTypesOfFarmSize TranslateFarmSizeCodes(string &str);
    TTypesOfAnimals TranslateAnimalsCodes (string &str);
    TTypesOfCrops TranslateCropsCodes (string &str);
    TTypesOfParameters TranslateParametersCodes (string &str);
    TTypesOfLivestockParameters TranslateLivestockParametersCodes (string &str);
    TTypesOfCropVariables TranslateCropVariablesCodes (string &str);
    DataForOptimisation * pm_data;
    ofstream * pm_output_file;
 
    int Get_lookup_table(int index){return m_crop_lookup_table[index];};
 
    int GetFarmNoLookup(int a_ref) { return m_farmmapping_lookup[a_ref * 2]; }
    int GetFarmTypeLookup(int a_ref) { return m_farmmapping_lookup[a_ref * 2 + 1]; }
    bool GetIsRenumbered() { return m_renumbered; }
    int GetRenumberedFarmRef(int a_farmref)
    {
        for (int i = 0; i < (int)m_farms.size(); i++)
        {
            if (m_farmmapping_lookup[i * 2] == a_farmref)
            {
                return i;
            }
        }
        g_msg->Warn( "FarmManager::GetRenumberedFarmRef(int a_farmref)  Farm reference number not found in m_farmmapping_lookup ", a_farmref );
        exit( 9 );
    }
    int GetNoFarms( ) {
        return (int)m_farms.size();
    }
 
 
protected:
    vector<Farm*> m_farms;
    Population_Manager * m_population_manager; 
    void  CreateFarms( const char *a_farmfile );
    double daydegrees;
    bool m_SpilledGrain;
    
    int* m_farmmapping_lookup;
    bool m_renumbered;
 
 
//for the optimisation
 
    struct PesticideData{
        TTypesOfVegetation Tov;
        double BIherb;
        double BIfi;
        double BI;
    };
 
    double totalOptFarmsArea;
    double totalOptFarmsArea_plant;
    double totalOptFarmsArea_pig;
    double totalOptFarmsArea_cattle;
    double totalOptFarmsArea_other;
 
    vector<double>m_cropTotals;
    vector<int>m_crop_lookup_table;
    vector<double>m_cropTotals_sum;
    vector<double>m_cropTotals_plant_sum;
    vector<double>m_cropTotals_pig_sum;
    vector<double>m_cropTotals_cattle_sum;
    vector<double>m_cropTotals_other_sum;
    vector<PesticideData>m_crops_summary_BIs;
    vector<double>m_crops_fertilizer;
    vector<double>m_crops_fertilizer_trade;
    vector<double>m_crop_areas_stages;
 
 
    //data at a farm level
    void ReadFarmsData();
    void ReadLivestockNumbers();
    void ReadInitialCropAreas();
 
    //data for farms
    void ReadFarmsData_perFarmType();
 
    //data for livestock
    void ReadLivestockData();
 
    //data for crops
    void ReadCropsData();
    void ReadCropsData_perSoilType();
    void ReadCropsData_perFarmType();
    void ReadCropsData_perFarm_and_Soil();
    void ReadCropsData_perFarm_and_Soil_and_Size();
 
    //data for almass crops:
    void ReadInitialCropAreas_almass();
    void ReadCropsData_almass();
    void ReadCropsData_perSoilType_almass();
    void ReadCropsData_perFarmType_almass();
    void ReadCropsData_perFarm_and_Soil_almass();
    void ReadCropsData_perFarm_and_Soil_and_Size_almass();
 
    //for energy maize runs
    void ReadEnergyMaizePrice();
 
    //methods
 
    void OptimisationOutput();
    void PrintOutput(TTypesOfCropVariables a_var, string a_fileName);
    void CropDistribution();
    void Create_Output_file_for_farms();
    void ReadLookupTable();
    void PrintNeighbours();
    void DistributeFarmerTypes();
 
};
 
 
class OptimisingFarm : public Farm
{
public:
    OptimisingFarm( FarmManager* a_myfarmmanager, int a_No);
    virtual ~OptimisingFarm() { ; } 
    TTypesOfOptFarms Get_farmType (void) {return m_farmType;}
    TTypesOfSoils Get_soilType (void) {return m_soilType;}
    TTypesOfFarmSize Get_farmSize (void) {return m_farmSize;}
    int Get_farmRealID (void) {return m_farmRealID;}
    int Get_soilSubType (void) {return m_soilSubType;}
    int Get_almass_no (void) {return m_almass_no;}
    CropOptimised* Get_crop (int i) {return m_crops[i];}
    int Get_cropsSize(void) {return (int)m_crops.size();}
    void Set_Livestock (Livestock* p_lvs){m_livestock.push_back(p_lvs);};
    void Set_Crop(CropOptimised* p_crop){m_crops.push_back(p_crop);};
 
    //-------------------------------------------------------------------------------------------------------------
    //for the modified dec. making - using CONSUMAT approach
 
    void Set_Neighbour(OptimisingFarm* farm){m_neighbours.push_back(farm);};
    int Get_NeighboursSize(void) {return (int)m_neighbours.size();};
    OptimisingFarm * Get_Neighbour (int i){return m_neighbours[i];};
    vector<AlmassCrop> Get_rotational_crops(){return m_rotational_crops;};
    vector<AlmassCrop> Get_rotational_crops_visible(){return m_rotational_crops_visible;}; 
    double Get_actual_profit() {return m_actual_profit;};
    double Get_actual_aggregated_yield() {return m_actual_aggregated_yield;};
    int GetFarmCentroidX() { return m_farm_centroidx; }
    int GetFarmCentroidY() { return m_farm_centroidy; }
    void Set_main_goal (TTypeOfFarmerGoal a_goal){m_main_goal = a_goal;};
    TTypeOfFarmerGoal Get_main_goal() {return m_main_goal;};
    void Set_animals_no (int a_number){animals_no = a_number;};
    int Get_decision_mode_counters (int index){return m_decision_mode_counters[index];};
    bool Harvest( LE *a_field, double a_user, int a_days );
    void Match_crop_to_field(LE* a_field);
    OptimisingFarm * Find_neighbour_to_imitate();
 
    void ActualProfit();
    void Save_last_years_crops();
    void ChooseDecisionMode();
    virtual bool Spraying_herbicides(TTypesOfVegetation a_tov_type);
    virtual bool Spraying_fungins(TTypesOfVegetation a_tov_type);
    virtual double Prob_multiplier ();
 
    //-------------------------------------------------------------------------------------------------------------
 
    void Init(ofstream * ap_output_file);
 
protected:
    virtual void InitiateManagement( void );
    void Initialize(FarmManager * a_pfm);
    virtual void HandleEvents( void );
    virtual bool FungicideTreat( LE *a_field, double /*a_user*/, int a_days );
    virtual bool InsecticideTreat( LE *a_field, double /*a_user*/, int a_days );
    virtual bool HerbicideTreat( LE *a_field, double /*a_user*/, int a_days );
 
    //----------------------------------------------------------------------------------------------------
    //'farmer' variables - for the modified decision making 
 
    TTypeOfFarmerGoal m_main_goal;
    //TTypeOfFarmerGoal m_pest_goal;
    //TTypeOfFarmerGoal m_fert_goal;
 
    vector<OptimisingFarm*>m_neighbours;
    double m_need_satisfaction_level;
    double m_certainty_level;
    vector<int>m_decision_mode_counters;
 
    //the actual and expected values
    double m_actual_profit;
    double m_exp_profit;
    double m_actual_income;
    double m_exp_income;
    double m_actual_costs;
    double m_exp_costs;
    double m_actual_aggregated_yield;
    double m_exp_aggregated_yield;
 
    vector<double>m_previous_profits;
    vector<double>m_previous_incomes;
    vector<double>m_previous_costs;
    vector<double>m_previous_aggregated_yields;
    vector<double>m_previous_satisfaction_levels;
    OptimisingFarm * m_previously_imitated_neighbour;
 
    vector<double>m_animals_numbers;
    bool force_deliberation;
    int animals_no;
 
    //-----------------------------------------------------------------------------------------------------
 
 
    //structs
    struct CropSort {
        double key;
        CropOptimised *crop;
    };
 
    struct reverseSort {
       bool operator()(CropSort a, CropSort b) { return a.key > b.key; }
    };
 
    struct MakeRotation {
        bool taken;
        TTypesOfVegetation Tov;
    };
 
 
    //lists - vectors
    vector<Livestock*>m_livestock;
    vector<CropOptimised*>m_crops;
    vector<CropSort>m_variableCrops;
    vector<CropSort>m_variableCrops2;
    vector<CropOptimised*>m_grownVariableCrops;
    vector<CropOptimised*>m_fixedCrops;
    vector<CropSort>m_rotationCrops;
    vector<CropSort>m_winterCrops;
    vector<AlmassCrop>m_crops_almass;
    vector<AlmassCrop>m_rotational_crops;
    vector<AlmassCrop>m_rotational_crops_copy;
    vector<AlmassCrop>m_rotational_crops_visible;
 
    //farm parameters (not-farm specific parameters are stored in the DataForOptimisation class)
    TTypesOfOptFarms m_farmType;
    TTypesOfSoils m_soilType;
    TTypesOfFarmSize m_farmSize;
    int m_farmRealID;
    int m_soilSubType;
    int m_almass_no;
 
    //variables
    double m_totalArea;
    double m_totalArea_original;
    double m_area_scaling_factor;
    double m_totalNanim;
    double m_Nanim;
    double m_totalFUdemandBefore;
    double m_totalFUdemand;
    double m_totalFUt;
    double m_totalFUgrown;
    double m_assigned;
    double m_totalN;
    double m_totalNt;
    double m_totalBIHerb;
    double m_totalBIFi;
    double m_totalBI;
    double m_totalGrooming;
    double m_totalHoeing;
    double m_totalWeeding;
    double m_totalCosts;
    double m_totalIncome;
    double m_totalProfit;
    double m_area_rot;
 
 
    // methods
 
    virtual void  createCropsLists(int a_foobar);
    void createVariableCrops(int a_foobar);
    void FarmLevelCalculation();
    void OptimiseFarm(int a_foobar);
 
    void Check_SG_and_CGG();
 
    //METHODS FOR FARM VARIABLES
    void findTotalArea();
    void findTotalNanim();
    void findNanim();
    virtual void findFodderDemand();
    virtual void preventCashCrops(){};
 
 
    //OPTIMISATION
    void optimizeCrops(int a_foobar);
 
    //OPTIMISATION - SIMPLIFIED METHOD
    void findFertilizer(CropOptimised * a_crop, int a_foobar, double benefit);
    void findResponse(CropOptimised * a_crop, int a_foobar);
    void findBIs(CropOptimised * a_crop, double benefit);
    void fixBI();
    void findMWeedControl(CropOptimised * a_crop);
    void findYieldLoss(CropOptimised * a_crop);
    void findGrossMargin(CropOptimised * a_crop, int a_foobar, double benefit);
 
    //AREA ASSIGNMENT
    void assignFixed();
    void sumMinAreas();
    virtual void determineAreas(int a_foobar);
    void determineAreas_ha(vector<CropOptimised*>crops);
 
    //RESTRICTIONS - CROPS AREA
    virtual void checkRestrictions();
    virtual void checkWinterRotation1(){}; 
    virtual void checkWinterCrops(){};
    void setRotationCropsAtMax();
 
    //OTHER FUNCTIONS
    double crop_parameter(int index, string par_name);
    CropOptimised * findCropByName (string crop_name);
    CropOptimised * findCropByName_almass (string crop_name);
    CropOptimised * findCropByName_almass (TTypesOfVegetation a_tov_type);
    double total(TTypesOfCropVariables variable_name);
    void sortCrops(vector<CropSort> &cropsToSort, string sortingKey);
    void randomizeCropList(vector<CropSort> &listToRandomize, string key);
    virtual void increaseCrops(vector<CropSort>cropsToIncrease, double &howMuchToIncrease);
    virtual void decreaseCrops(vector<CropSort>cropsToDecrease, double &howMuchToDecrease);
    void Print_FarmVariables (ofstream * ap_output_file);
    void Make_rotations();
    void Check_if_area_100();
    void Translate_crops_to_almass();
    void Make_almass_crops_vector();
    void Make_rotational_crops();
    void Print_rotations(ofstream * ap_output_file);
 
};
 
class  AnimalFarm: public OptimisingFarm{
public:
     AnimalFarm(FarmManager * a_myfarmmanager, int a_No);
     virtual ~AnimalFarm(){};
protected:
 
     CropOptimised *m_fakeCrop;
     bool m_fakeCropTest;
    vector<CropSort>m_fodderCrops;
 
     //variables
 
    double m_totalFodderToProduce;
    double m_fodderToProduce;
    double m_fodderToProduceBefore;
    bool cash_crops_allowed;
 
    //methods
    virtual void createCropsLists(int a_foobar);
    virtual void determineAreas(int a_foobar);
 
    //FODDER CROPS
    void createFodderCrops(int a_foobar);
    void findFodderCropSavings();
    void correctFodderDemand(int a_foobar);
    void determineFodderAreas(int a_foobar);
    void determineMinFodder(int a_foobar);
 
    //RESTRICTIONS - CROPS AREA
    virtual void checkWinterRotation1(); 
    virtual void checkWinterCrops();
 
    //OTHER
    virtual void increaseCrops(vector<CropSort>cropsToIncrease, double &howMuchToIncrease);
    virtual void decreaseCrops(vector<CropSort>cropsToDecrease, double &howMuchToDecrease);
 
};
 
class OptimisingPigFarm: public AnimalFarm{
public:
    OptimisingPigFarm(FarmManager* a_myfarmmanager, int a_No);
    virtual ~OptimisingPigFarm(){};
 
protected:
    virtual void checkRestrictions();
    void check_WRape_WBarley();
};
 
class OptimisingCattleFarm: public AnimalFarm{
public:
    OptimisingCattleFarm(FarmManager* a_myfarmmanager, int a_No);
    virtual ~OptimisingCattleFarm(){};
 
protected:
    vector<CropSort>m_cattleCrops;
    vector<CropSort>m_cattleCrops_almass;
    virtual void checkRestrictions();
    void checkCattleRotation();
    void checkCattleRotation_almass();
    void setCattleCropsAtMin();
    virtual void preventCashCrops();
 
};
 
 
class  NonAnimalFarm: public OptimisingFarm{
public:
    NonAnimalFarm(FarmManager * a_myfarmmanager, int a_No);
    virtual ~NonAnimalFarm(){};
protected:
 
    //methods
    //METHODS FOR FARM VARIABLES
    virtual void findFodderDemand();
 
    //RESTRICTIONS
    virtual void checkWinterRotation1(); 
    virtual void checkWinterCrops();
};
 
class OptimisingPlantFarm: public NonAnimalFarm{
public:
    OptimisingPlantFarm(FarmManager* a_myfarmmanager, int a_No);
    virtual ~OptimisingPlantFarm(){};
};
 
class OptimisingOtherFarm: public NonAnimalFarm{
public:
    OptimisingOtherFarm(FarmManager* a_myfarmmanager, int a_No);
    virtual ~OptimisingOtherFarm(){};
};
 
 
 
 
 
#endif // FARM_H